const WebSocket = require('ws');
const readline = require('readline');

// 创建命令行交互界面
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: 'test-client-wss> '
});

// 默认配置 - 云托管的wss连接信息
const DEFAULT_CONFIG = {
  cloud: {
    url: 'wss://tcb-ws.tencentcloudapi.com/web_socket',
    service: 'robot',
    env: 'prod-0gjrhbe3985f006d'
  },
  local: {
    url: 'ws://localhost:80'
  }
};

// 存储接收到的历史数据
let receivedHistory = [];
let ws = null;
let currentConnectionType = 'cloud'; // 默认连接到云托管服务

// 连接WebSocket服务器
function connectWebSocket(connectionType = 'cloud') {
  currentConnectionType = connectionType;
  
  // 关闭现有的连接（如果有）
  if (ws) {
    ws.close();
  }
  
  const config = connectionType === 'cloud' ? DEFAULT_CONFIG.cloud : DEFAULT_CONFIG.local;
  let wsUrl;
  let wsOptions = {};
  
  if (connectionType === 'cloud') {
    // 云托管服务需要添加请求头和协议参数
    wsUrl = config.url + '/web_socket';
    wsOptions = {
      headers: {
        'X-WX-SERVICE': config.service,
        'X-WX-ENV': config.env
      },
      protocols: ['protocol1']
    };
  } else {
    // 本地服务器连接
    wsUrl = config.url;
  }
  
  console.log(`\n🌐 正在连接到${connectionType === 'cloud' ? '云托管服务' : '本地服务器'}: ${wsUrl}`);
  if (connectionType === 'cloud') {
    console.log(`📝 连接头信息: X-WX-SERVICE=${config.service}, X-WX-ENV=${config.env}`);
  }
  
  // 创建WebSocket连接
  ws = new WebSocket(wsUrl, wsOptions);

  // 连接成功处理
  ws.on('open', () => {
    console.log(`✅ 成功连接到${connectionType === 'cloud' ? '云托管服务' : '本地服务器'}`);
    console.log('📝 输入命令进行测试（输入 help 查看可用命令）');
    
    // 发送上线通知
    sendOnlineNotification();
    
    // 发送上线日志到MQTT主题
    const onlineLog = {
      type: 'online',
      ts: Date.now(),
      ver: 'v0.2.0-test',
      from: 'test_client_wss',
      connectionType: currentConnectionType
    };
    publishMessage('/robot/zack/vbat', JSON.stringify(onlineLog));
    
    // 订阅业务数据主题
    subscribeTopic('/robot/zack/vbat');
    
    // 从云托管获取历史数据
    getHistory();
    
    rl.prompt();
  });

  // 接收消息处理 - 增强日志记录，便于调试
  ws.on('message', (data) => {
    try {
      const message = JSON.parse(data.toString());
      console.log(`\n📥 收到服务器消息:`);
      console.log(`📋 消息类型: ${message.type || 'unknown'}`);
      console.log(`📊 消息内容:`, JSON.stringify(message, null, 2));
      
      // 处理特定类型的消息
      switch(message.type) {
        case 'history_data':
          receivedHistory = message.data;
          console.log(`📊 收到 ${receivedHistory.length} 条历史电压数据`);
          break;
        case 'pong':
          console.log('🏓 收到心跳响应');
          break;
        case 'message':
          console.log(`📬 收到来自MQTT的消息 (主题: ${message.topic || 'unknown'})`);
          console.log(`📄 MQTT消息内容: ${message.payload}`);
          break;
        case 'test_response':
          console.log('✅ 收到测试响应，链路测试成功！');
          console.log(`🔍 服务器调试信息:`, JSON.stringify(message.debugInfo || {}, null, 2));
          break;
        case 'publish_response':
          if (message.success) {
            console.log(`✅ 发布消息成功 (主题: ${message.topic})`);
          } else {
            console.error(`❌ 发布消息失败: ${message.error || 'Unknown error'}`);
          }
          break;
        case 'subscribe_response':
          if (message.success) {
            console.log(`✅ 订阅主题成功 (主题: ${message.topic})`);
          } else {
            console.error(`❌ 订阅主题失败: ${message.error || 'Unknown error'}`);
          }
          break;
        case 'connect':
          if (message.success) {
            console.log(`✅ MQTT服务器连接成功`);
          } else {
            console.error(`❌ MQTT服务器连接失败: ${message.error || 'Unknown error'}`);
          }
          break;
        case 'mqtt_error':
          console.error(`❌ MQTT错误: ${message.error || 'Unknown error'}`);
          break;
        default:
          console.log(`ℹ️  收到未处理的消息类型: ${message.type}`);
      }
    } catch (error) {
      console.error('❌ 解析消息失败:', error);
      console.log(`📄 原始消息内容: ${data.toString()}`);
    }
    rl.prompt();
  });

  // 连接关闭处理
  ws.on('close', () => {
    console.log(`🔌 与${connectionType === 'cloud' ? '云托管服务' : '本地服务器'}的连接已关闭`);
  });

  // 连接错误处理
  ws.on('error', (error) => {
    console.error(`❌ WebSocket连接错误:`, error.message);
    console.log(`💡 提示：如果连接云托管服务失败，请检查网络连接和配置是否正确。\n`);
    rl.prompt();
  });
}

// 发送上线通知
function sendOnlineNotification() {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  ws.send(JSON.stringify({
    type: 'online_notification',
    timestamp: new Date().toISOString()
  }));
  console.log('📤 已发送上线通知');
}

// 发送MQTT发布消息
function publishMessage(topic = '/robot/zack/vbat', payload = 'Test message') {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  ws.send(JSON.stringify({
    type: 'publish',
    topic: topic,
    payload: payload
  }));
  console.log(`📤 已发送发布消息到主题: ${topic}`);
}

// 订阅MQTT主题
function subscribeTopic(topic = '/robot/zack/vbat') {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  ws.send(JSON.stringify({
    type: 'subscribe',
    topic: topic
  }));
  console.log(`📤 已发送订阅请求到主题: ${topic}`);
}

// 取消订阅MQTT主题
function unsubscribeTopic(topic = '/robot/zack/vbat') {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  ws.send(JSON.stringify({
    type: 'unsubscribe',
    topic: topic
  }));
  console.log(`📤 已发送取消订阅请求到主题: ${topic}`);
}

// 发送测试电压数据
function sendTestVoltage(voltage = 4.2) {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  const testPayload = JSON.stringify({
    type: 'voltage_data',
    vbat: voltage,
    timestamp: Date.now(),
    device: 'test_client_wss'
  });
  
  publishMessage('/robot/zack/vbat', testPayload);
}

// 发送告警测试消息
function sendAlertTest(voltage = 4.0) {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  const alertPayload = JSON.stringify({
    type: 'voltage_data',
    vbat: voltage,
    timestamp: Date.now(),
    device: 'test_client_wss',
    alert_test: true
  });
  
  publishMessage('/robot/zack/vbat', alertPayload);
  console.log(`⚠️  已发送告警测试消息 (电压: ${voltage}V)`);
}

// 获取历史数据
function getHistory() {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  ws.send(JSON.stringify({
    type: 'get_history'
  }));
  console.log('📤 已发送获取历史数据请求');
}

// 清空历史数据
function clearHistory() {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  ws.send(JSON.stringify({
    type: 'clear_history'
  }));
  console.log('📤 已发送清空历史数据请求');
}

// 设置电压阈值
function setVoltageThresholds(lower, upper) {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  const thresholdsPayload = JSON.stringify({
    type: 'set_thresholds',
    lower: parseFloat(lower),
    upper: parseFloat(upper),
    timestamp: Date.now(),
    device: 'test_client_wss'
  });
  
  console.log(`⚙️  设置电压阈值: 低压=${lower}V, 高压=${upper}V`);
  publishMessage('/robot/zack/vbat', thresholdsPayload);
}

// 发送链路测试消息 - 确保格式与云托管服务器处理逻辑匹配
function sendLinkTest() {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    console.error('❌ WebSocket未连接');
    return;
  }
  
  // 构建与云托管服务器期望格式完全匹配的测试消息
  // 同时设置type和vbat字段为'test'，确保触发服务器的测试响应逻辑
  const testPayload = JSON.stringify({
    type: 'test',
    vbat: 'test',
    voltage: 'test', // 同时设置voltage字段，确保匹配云托管服务器的检查条件
    timestamp: Date.now(),
    device: 'test_client_wss',
    test_mode: true
  });
  
  console.log('🔍 发送链路测试消息到主题: /robot/zack/vbat');
  console.log('📋 测试消息内容:', testPayload);
  
  publishMessage('/robot/zack/vbat', testPayload);
  console.log('🔍 已发送链路测试消息，等待响应...');
}

// 切换连接类型
function switchConnectionType(type) {
  if (type !== 'cloud' && type !== 'local') {
    console.error('❌ 无效的连接类型，请使用 cloud 或 local');
    return;
  }
  
  if (type === currentConnectionType) {
    console.log(`ℹ️  已经连接到${type === 'cloud' ? '云托管服务' : '本地服务器'}`);
    return;
  }
  
  console.log(`🔄 正在切换到${type === 'cloud' ? '云托管服务' : '本地服务器'}...`);
  connectWebSocket(type);
}

// 命令行处理
rl.on('line', (line) => {
  const command = line.trim().toLowerCase();
  const parts = command.split(' ');
  const cmd = parts[0];
  const args = parts.slice(1);
  
  switch(cmd) {
    case 'help':
      console.log('\n📋 可用命令:');
      console.log('  help                      - 显示帮助信息');
      console.log('  publish [topic] [payload] - 发布消息到MQTT主题');
      console.log('  subscribe [topic]         - 订阅MQTT主题');
      console.log('  unsubscribe [topic]       - 取消订阅MQTT主题');
      console.log('  voltage [value]           - 发送测试电压数据');
      console.log('  alert [value]             - 发送告警测试电压');
      console.log('  history                   - 获取历史电压数据');
      console.log('  clear                     - 清空历史电压数据');
      console.log('  test                      - 发送链路测试消息');
      console.log('  thresholds [lower] [upper] - 设置电压告警阈值');
      console.log('  switch [cloud|local]      - 切换连接类型（云托管/本地）');
      console.log('  exit                      - 退出程序');
      console.log('\n🌐 当前连接类型:', currentConnectionType === 'cloud' ? '云托管服务 (wss)' : '本地服务器 (ws)');
      break;
      
    case 'publish':
      if (args.length > 0) {
        publishMessage(args[0], args.slice(1).join(' ') || 'Test message');
      } else {
        publishMessage();
      }
      break;
      
    case 'subscribe':
      if (args.length > 0) {
        subscribeTopic(args[0]);
      } else {
        subscribeTopic();
      }
      break;
      
    case 'unsubscribe':
      if (args.length > 0) {
        unsubscribeTopic(args[0]);
      } else {
        unsubscribeTopic();
      }
      break;
      
    case 'voltage':
      if (args.length > 0) {
        sendTestVoltage(parseFloat(args[0]));
      } else {
        sendTestVoltage();
      }
      break;
      
    case 'alert':
      if (args.length > 0) {
        sendAlertTest(parseFloat(args[0]));
      } else {
        sendAlertTest();
      }
      break;
      
    case 'history':
      getHistory();
      break;
      
    case 'clear':
      clearHistory();
      break;
      
    case 'test':
      sendLinkTest();
      break;
      
    case 'switch':
      if (args.length > 0) {
        switchConnectionType(args[0]);
      } else {
        console.error('❌ 请指定连接类型: cloud 或 local');
      }
      break;
    
    case 'thresholds':
      if (args.length >= 2) {
        setVoltageThresholds(args[0], args[1]);
      } else {
        console.error('❌ 请指定低压阈值和高压阈值，格式: thresholds [lower] [upper]');
        console.log('例如: thresholds 3.15 3.30');
      }
      break;
      
    case 'exit':
      console.log('👋 再见！');
      process.exit(0);
      break;
      
    default:
      console.log('❓ 未知命令，请输入 help 查看可用命令');
  }
  
  rl.prompt();
}).on('close', () => {
  console.log('👋 再见！');
  process.exit(0);
});

// 显示欢迎信息
console.log('🚀 MQTT代理服务器测试客户端 (WSS版)');
console.log('ℹ️  支持连接云托管服务(wss)和本地服务器(ws)');
console.log('⏳ 正在连接到云托管服务...');

// 默认连接到云托管服务
connectWebSocket('cloud');